AVL树C++实现

最新推荐文章于 2023-06-15 15:30:47 发布
最新推荐文章于 2023-06-15 15:30:47 发布
阅读量159 收藏
点赞数
分类专栏： 算法导论 文章标签： 算法导论 c语言 AVL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_15652045/article/details/76304627
版权

用类封装AVL的几个属性，应该没有问题，如果有错请告知我，谢谢

其中打印树参考http://www.cnblogs.com/skywang12345/p/3577479.html

头文件

#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

void testavl();


主函数 

#include "Header.h"

int main()
{
	testavl();
	return 0;
}


AVL类实现 

#include "Header.h"

struct node
{
	node* leftchild;
	node* rightchild;
	node* parents;
	int key;
	node(){};
	node(int a){ leftchild = NULL; rightchild = NULL; parents = NULL; key = a; };
};

class AVL
{
public:
	AVL();
	node* root_node;
	int Height(node* nd);
	void Insert(node* nd);
	void LeftRotate(node* nd);
	void RightRotate(node* nd);
	node* MinChild(node* nd);
	void Transplant(node *u, node *v);
	void Delete(node* nd);
	void Delete(int value);
	void InsertFixup(node* nd);
	void DeleteFixup(node* nd);
};

AVL::AVL()
{
	root_node = NULL;//用哨兵编程会简单一点，写的时候没有用哨兵
	
}




inline int max(int x, int y)
{
	return x > y ? x : y;
}

node* AVL::MinChild(node* nd) //返回以nd为根节点的子树的关键词最小节点
{
	node* min;
	min = NULL;
	while (nd)
	{
		min = nd;
		nd = nd->leftchild;
	}

	return min;
}

void AVL::Delete(node* nd)
{
	if (nd->leftchild == NULL && nd->rightchild == NULL)
	{
		if (nd->parents == NULL)
		{
			root_node == NULL;
		}
		else
		{
			if (nd == nd->parents->leftchild)
			{
				nd->parents->leftchild = NULL;
			}
			else
			{
				nd->parents->rightchild = NULL;
			}
			DeleteFixup(nd->parents);
		}
	}
	else
	{
		if (nd->leftchild == NULL)
		{
			if (nd->rightchild)
			{
				Transplant(nd, nd->rightchild);
			}
			DeleteFixup(nd->parents);
		}
		else if (nd->rightchild == NULL)
		{
			if (nd->leftchild)
			{
				Transplant(nd, nd->leftchild);
			}
			DeleteFixup(nd->parents);
		}
		else
		{
			node* z;
			z = MinChild(nd->rightchild);
			node* x;
			x = z->parents;
			if (z->parents != nd)
			{
				Transplant(z, z->rightchild);
				z->rightchild = nd->rightchild;
				z->rightchild->parents = z;
			}
			else
			{
				x = z;
			}
			Transplant(nd, z);
			z->leftchild = nd->leftchild;
			z->leftchild->parents = z;
			DeleteFixup(x);
		}
	}
	
	
	

}

int AVL::Height(node* nd)
{
	if (nd == NULL)
	{
		return 0;
	}
	else
	{
		return max(Height(nd->leftchild), Height(nd->rightchild)) + 1;
	}
}

void AVL::Transplant(node *u, node *v)
{
	
	if (/*root_node == u*/u->parents == NULL)
	{
		root_node = v;
	}
	else if (u == u->parents->leftchild)
	{
		u->parents->leftchild = v;
	}
	else
	{
		u->parents->rightchild = v;
	}
	if (v)
	{
		v->parents = u->parents;
	}
	
}

void AVL::Insert(node* nd)
{
	node* x = new node;
	x = root_node;
	node* y = NULL;
	
	while (x)
	{
		y = x;
		if (nd->key > x->key)
		{
			x = x->rightchild;
		}
		else
		{
			x = x->leftchild;
		}
	}

	if (y == NULL)
	{
		root_node = nd;
	}
	else
	{
		nd->parents = y;

		if (nd->key > y->key)
		{
			y->rightchild = nd;
		}
		else
		{
			y->leftchild = nd;
		}
	}

	if (nd->parents != NULL)
	{
		InsertFixup(nd->parents);
	}
	
}


void AVL::InsertFixup(node* nd)
{
	node* r;// record_location;
	node* r_p;// parents of r;
	r = nd;
	

	while (r->parents != NULL)
	{
 		r_p = r->parents;

		int r_bf = Height(r->rightchild) - Height(r->leftchild);//可以写成节点的一个属性
		//int rp_bf = Height(r_p->rightchild) - Height(r_p->leftchild);///

		int rp_bf = 0;
		int rr = Height(r_p->rightchild);
		int rl = Height(r_p->leftchild);
		rp_bf = rr - rl;

		if (rp_bf == 2)// 
		{
			if (r_bf == 1)
			{
				LeftRotate(r_p);
			}
			else
			{
				RightRotate(r);
				LeftRotate(r->parents->parents);
				//RLRotate
			}
		}
		else if (rp_bf == -2)
		{
			if (r_bf == 1)
			{
				LeftRotate(r);
				RightRotate(r->parents->parents);
			}
			else
			{
				RightRotate(r_p);
			}
		}

		r = r->parents;
		if (r == NULL)
		{
			break;
		}
	}
}


void AVL::DeleteFixup(node* nd)
{
	while (nd != NULL)
	{
		if (Height(nd->rightchild) - Height(nd->leftchild) == -2)
		{
			if (Height(nd->leftchild->rightchild) - Height(nd->leftchild->leftchild) == -1)
			{
				RightRotate(nd);
			}
			else
			{
				LeftRotate(nd->leftchild);
				RightRotate(nd);
			}
		}
		else if (Height(nd->rightchild) - Height(nd->leftchild) == 2)
		{
			if (Height(nd->rightchild->rightchild) - Height(nd->rightchild->leftchild) == -1)
			{
				RightRotate(nd->rightchild);
				LeftRotate(nd);
			}
		}

		nd = nd->parents;
	}
}


void AVL::LeftRotate(node* nd)
{
	node* y;
	y = nd->rightchild;
	nd->rightchild = y->leftchild;

	if (y->leftchild != NULL)
	{
		y->leftchild->parents = nd;
	}

	y->parents = nd->parents;

	if (nd->parents == NULL)
	{
		root_node = y;
	}
	else if (nd == nd->parents->leftchild)
	{
		nd->parents->leftchild = y;
	}
	else
	{
		nd->parents->rightchild = y;
	}

	y->leftchild = nd;
	nd->parents = y;
}

void AVL::RightRotate(node* nd)
{
	node* y;
	y = nd->leftchild;
	nd->leftchild = y->rightchild;

	if (y->rightchild != NULL)
	{
		y->rightchild->parents = nd;
	}

	y->parents = nd->parents;

	if (nd->parents == NULL)
	{
		root_node = y;
	}
	else if (nd == nd->parents->leftchild)
	{
		nd->parents->leftchild = y;
	}
	else
	{
		nd->parents->rightchild = y;
	}

	y->rightchild = nd;
	nd->parents = y;
}




void PrintTree(node* nd, int nodekey, int direction) //打印以nd为根的子树的所有元素
{
	if (nd != NULL)
	{
		if (direction == 0)
		{
			cout << setw(2) << nd->key << " is root" << endl;
		}
		else
		{
			string s;
			s = direction == 1 ? "right" : "left";
			cout <<setw(2) << nd->key << " is " << setw(2) << nodekey << "'s ";
			cout <<setw(6) <<  s;
			cout << " child" << endl;
		}
		PrintTree(nd->leftchild, nd->key, -1);
		PrintTree(nd->rightchild, nd->key, 1);
	}

}

void testavl()
{
	
	AVL test_tree;
	int nodekey[16] = { 3, 2, 1, 4, 5, 6, 7, 16, 15, 14, 13, 12, 11, 10, 8, 9 };
	node* test_nodes = new node[16];

	for (int i = 0; i < 16; i++)
	{

		test_nodes[i].key = nodekey[i];
		test_nodes[i].leftchild = test_nodes[i].rightchild = test_nodes[i].parents = NULL;
		test_tree.Insert(&test_nodes[i]);
		cout << i << endl;
	}
	
	cout << "生成的AVL为：" << endl;
	PrintTree(test_tree.root_node, test_tree.root_node->key, 0);
	test_tree.Delete(test_tree.root_node);

	cout << "删除根节点之后的AVL为：" << endl;
	PrintTree(test_tree.root_node, test_tree.root_node->key, 0);
	
}





Abecedarian_Image
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL树详解（附c++代码）
u012148952的博客
08-14 5243
详解AVL树的左旋和右旋，以及插入和删除两种基本操作。并且实现一颗简单的AVL树
AVL树 C++ 实现
03-05
平衡二叉树(AVL)的C++实现。 用泛型写的。 IDE为VS2008 好像没别的了~ 就怎么个东西
C++：AVL树
zhang_si_hang的博客
08-19 860
二叉搜索树虽可以缩短查找的效率，但。
C++数据结构 —— AVL树
weixin_59913110的博客
02-26 518
AVL树是map/set/multimap/multi/set等容器的一种底层结构，其本质就是一颗二叉搜索树。但因为二叉搜索树很容易退化成单支树，所以AVL树便是对二叉搜索树进行升级改造，使其平衡。向二叉搜索树插入节点，保证每个节点的左右子树高度差不超过1(可以包括1)，如果确实达不到这种要求，就需要通过特定的算法来达到这样的要求。一颗AVL树可以是空树，也可以是具有以下性质的二叉搜索树1.每个节点的左右子树都是AVL树2.每个节点的左右子树的高度差不超过1(可以包括1)
c++——AVL树
Britney_dark的博客
11-08 1345
如果结果不如你所愿，就在尘埃落定前奋力一搏！
【C++】-- AVL树详解
局部变量和全局变量
08-31 2342
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： (1)它的左右子树都是AVL树 (2)左右子树高度之差(简称平衡因子=右子树高度-左子树高度)的绝对值不超过1(-1/0/1)
AVL树的c++实现
08-03
利用模板类以及智能指针shared_ptr写的关于AVL树的基本实现
C++实现AVL树
11-15
C++实现AVL树,有兴趣的可以看看，可能不是很好，仅作为参考
AVL树(C++实现)
清欢Allen的技术博客
04-14 1035
我们实现的是KV模型的AVL树,为了方便后续的操作,这里AVL树结点定义为三叉链结构,并且引入平衡因子,方便判断每棵树的平衡情况,并且还需要一个初始化列表将结点成员全部初始化.//三叉链 AVLTreeNode < K , V > * _left;//存储键值对 int _bf;
详解c++---AVL树的原理和实现
最新发布
qq_68695298的博客
06-15 474
用平衡因子来实现avl树
数据结构之AVL树（C++实现）
CHAKMING1的博客
01-12 519
介绍了二叉搜索树如何优化到AVL树，介绍了AVL树的概念，用代码实现了插入和验证是否为AVL树的方法。
【C++实现AVL树】
Undefined__yu的博客
02-06 580
本篇文章主要是介绍了AVL树的插入，对其中的四种旋转方法做了详解。过程中有图示和例子，包括完整代码，较好理解。
【C++】AVL树
kdjjdjdjjejje128的博客
03-05 549
AVL树的学习
数据结构(C++) : AVL树 实现篇
weixin_57761086的博客
10-08 2828
在二叉搜索树的基础上学习AVL树，通过大量图片学习AVL树的重点：左单旋，右单旋，左右双旋，右左双旋。同时写出验证函数，验证是否是AVL树
AVL树的详细实现(C++)
code_peak
10-05 4320
AVL树概念 前面已经介绍了二叉搜索树，但是二叉搜索树在某些情况下会出现极度不平衡，其树形结构便退化成了链表，查找效率也会下降。于是出现了 AVL 树，AVL 树保证了二叉搜索树的平衡，引入了平衡监督机制，也就是在插入结点时，树中某一部分不平衡度超过一个阈值后将出发平衡调整操作，这样便保证了树的平衡度在可接受的范围内，最大的好处就是提高了搜索的效率。 AVL 树是一种平衡二叉树，其名字来源于发明者的名字（Adelson-Velskii 以及 Landis）。AVL树的递归定义如下： 左右子树的高度差小于等
C++之AVL树
cls的博客
05-23 745
前面对map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是： 其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。 AVL 树 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表
【C++】 AVL树
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
11-05 565
AVL树的实现和应用
C++进阶 —— AVL树
NapoleonCoder的博客
12-11 733
AVL树！
avl树c++
05-24
AVL树是一种自平衡二叉搜索树，它的每个节点存储一个键值对，且每个节点的左子树和右子树的高度差不超过1。这种平衡特性使得AVL树在查找、插入和删除操作方面都有很好的性能表现。 下面是一个简单的AVL树的C++实现： ```c++ #include <iostream> using namespace std; // AVL树节点 struct Node { int key; int height; Node *left; Node *right; Node(int k) : key(k), height(1), left(NULL), right(NULL) {} }; // 获取节点高度 int height(Node *node) { if (node == NULL) { return 0; } return node->height; } // 获取节点平衡因子 int balanceFactor(Node *node) { if (node == NULL) { return 0; } return height(node->left) - height(node->right); } // 更新节点高度 void updateHeight(Node *node) { node->height = max(height(node->left), height(node->right)) + 1; } // 右旋操作 Node* rightRotate(Node *node) { Node *leftChild = node->left; Node *rightChild = leftChild->right; leftChild->right = node; node->left = rightChild; updateHeight(node); updateHeight(leftChild); return leftChild; } // 左旋操作 Node* leftRotate(Node *node) { Node *rightChild = node->right; Node *leftChild = rightChild->left; rightChild->left = node; node->right = leftChild; updateHeight(node); updateHeight(rightChild); return rightChild; } // 插入节点 Node* insert(Node *node, int key) { if (node == NULL) { return new Node(key); } if (key < node->key) { node->left = insert(node->left, key); } else if (key > node->key) { node->right = insert(node->right, key); } else { return node; } updateHeight(node); int bf = balanceFactor(node); if (bf > 1) { if (balanceFactor(node->left) >= 0) { return rightRotate(node); } else { node->left = leftRotate(node->left); return rightRotate(node); } } else if (bf < -1) { if (balanceFactor(node->right) <= 0) { return leftRotate(node); } else { node->right = rightRotate(node->right); return leftRotate(node); } } return node; } // 中序遍历AVL树 void inOrder(Node *node) { if (node == NULL) { return; } inOrder(node->left); cout << node->key << " "; inOrder(node->right); } int main() { Node *root = NULL; root = insert(root, 10); root = insert(root, 20); root = insert(root, 30); root = insert(root, 40); root = insert(root, 50); root = insert(root, 25); inOrder(root); cout << endl; return 0; } ``` 在上面的实现中，我们使用了递归插入节点，并在插入节点后更新了节点的高度和平衡因子。当节点的平衡因子大于1或小于-1时，我们进行相应的旋转操作来保持树的平衡。最后，我们在main函数中插入一些节点，并进行中序遍历来检查树是否正确构建。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值